# 导入电极控制模块和线程相关模块
from utils.electrode_ctrl import ElectrodeCtrl
from threading import Thread, Event
import sched, time  # 导入调度器和时间模块
import numpy as np  # 导入Numpy库，用于数组操作
from utils.voltage_adjust import set_volt  # 导入电压调整功能

# 初始化参数字典，用于存储脉冲参数
num_arrays = 2 # 电极阵列数量
param_dict = [{} for i in range(num_arrays)]  # 为每个阵列创建一个参数字典
#t = None  # 初始化线程对象
t_flag = [True for i in range(num_arrays)]  # 线程控制标志，用于控制线程的执行
t_evts = [Event() for i in range(num_arrays)]  # 线程事件对象，用于线程间同步
sches = [sched.scheduler(time.time_ns, lambda ns: time.sleep(ns / 1_000_000_000.0)) for i in range(num_arrays)]  # 创建调度器实例列表
threads = [None for i in range(num_arrays)]  # 创建线程实例列表
# 使用了thread 不需要用这种全局变量了sch_flags = [False for i in range(num_arrays)]  # 调度器控制标志，用于控制调度器的执行

def set_pulse(array_index, elec, arr, burst_period_ms, pulse_count, pulse_period_ms, pulse_width_percent, voltage, pulse_type):
    """设置脉冲参数，并触发线程开始执行脉冲调度。
    
    参数:
    array_index -- 电极阵列的索引
    elec -- 电极控制对象
    arr -- 电极阵列的初始状态
    burst_period_ms -- 脉冲组周期（毫秒）
    pulse_count -- 单个脉冲组中的脉冲数量
    pulse_period_ms -- 单个脉冲的周期（毫秒）
    pulse_width_percent -- 脉冲宽度占周期的百分比
    voltage -- 脉冲电压
    pulse_type -- 脉冲类型（正脉冲或负脉冲）
    """
    global param_dicts, t_evts
    param_dicts[array_index] = locals()  # 存储局部变量到param_dict
    t_evts[array_index].set()  # 触发事件，通知线程开始处理

def stop_pulse(array_index):
    """停止产生脉冲"""
    global t_flags
    t_flags[array_index] = False  # 停止调度器?线程
def null_func():
    """空函数，用于调度器占位"""
    pass

def pulse_thread(array_index):
    """脉冲生成线程函数，控制脉冲的生成和调度"""
    global param_dicts, sches, t_flags, t_evts
    while t_flags[array_index]:
        if t_evts[array_index].is_set():  # 事件触发
            param_dict = param_dicts[array_index]  # 获取参数字典
            set_volt(param_dict['voltage'])  # 设置电压

            # 计算激活和停止时间
            t_activate = 0
            t_period = param_dict['pulse_period_ms'] * 1_000_000
            t_deactivate = param_dict['pulse_period_ms'] * param_dict['pulse_width_percent'] * 10_000

            # 根据脉冲类型决定阵列激活和停止状态
            arr_activate = param_dict['arr'] if param_dict['pulse_type']=='pos' else (1 - param_dict['arr'])
            arr_deactivate = np.zeros((8,8)) if param_dict['pulse_type']=='pos' else np.ones((8,8))
            func_activate=lambda: param_dict['elec'].set_array(arr_activate)
            func_deactivate = lambda: param_dict['elec'].set_array(arr_deactivate)

            # 调度器安排电极激活、停止和脉冲间隔
            sches[array_index].enter(0, 0, action=param_dict['elec'].on)   #enter(delay, priority, action, argument=(), kwargs={})
            for i in range(param_dict['pulse_count']):
                sches[array_index].enter(t_activate, 0, action=func_activate)
                sches[array_index].enter(t_deactivate, 0, action=func_deactivate)
                t_activate += t_period                      # activate after every pulse_period_ms
                t_deactivate += t_period                    # deactivate after every pulse_period_ms
            sches[array_index].enter(t_activate, 0, action=param_dict['elec'].off)
            sches[array_index].enter(param_dict['burst_period_ms'] * 1_000_000, 0, action=null_func)
            sches[array_index].run(blocking=True)
            t_evts[array_index].clear()  # 清除事件，等待下一次触发
        else:
            t_evts[array_index].wait()  # 等待事件触发

def start_pulse_manager():
    """启动脉冲管理线程"""
    global threads
    delay_between_starts = 0.01  # 10ms 延迟
    for index in range(len(threads)):
        threads[index]=Thread(target=pulse_thread,args=(index,),daemon=True)
        threads[index].start()
        time.sleep(delay_between_starts)  # 延迟启动
